package demo;

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class sparseArray {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 1. 输入棋盘大小
        System.out.print("请输入棋盘大小（i×i，如3表示3×3）：");
        int size = sc.nextInt();
        int[][] originalBoard = new int[size][size];

        // 2. 随机生成棋子（1=黑，2=白）
        Random ra = new Random();
        int pieceCount = ra.nextInt(1, size * size + 1); // 随机棋子数（1到size²）
        System.out.println("随机生成了" + pieceCount + "个棋子：");

        for (int i = 0; i < pieceCount; i++) {
            int color = ra.nextInt(1, 3); // 1或2（黑白子）
            int x = ra.nextInt(0, size);  // 行索引（0到size-1）
            int y = ra.nextInt(0, size);  // 列索引（0到size-1）
            originalBoard[x][y] = color;
        }

        // 3. 打印原棋盘
        System.out.println("原棋盘：");
                printBoard(originalBoard);

        // 4. 生成**正确的稀疏数组**
        int[][] sparseArray = createSparseArray(originalBoard);
        System.out.println("原稀疏数组：");
                System.out.println(Arrays.deepToString(sparseArray));

        // 5. 翻转原棋盘（上下翻转）
        int[][] reversedBoard = reverseRows(originalBoard);
        System.out.println("翻转后的棋盘：");
                printBoard(reversedBoard);

        // 6. 生成翻转后的稀疏数组（无需翻转稀疏数组，直接翻转原棋盘）
        int[][] reversedSparseArray = createSparseArray(reversedBoard);
        System.out.println("翻转后的稀疏数组：");
                System.out.println(Arrays.deepToString(reversedSparseArray));
    }

    /**
     * 创建正确的稀疏数组
     * @param original 原棋盘数组
     * @return 稀疏数组（行=非零元素数+1，列=3；行0是表头：总行、总列、非零数）
     */
    public static int[][] createSparseArray(int[][] original) {
        if (original == null || original.length == 0) return new int[0][0];

        int rows = original.length;
        int cols = original[0].length;
        int nonZeroCount = 0;

        // 统计非零元素个数
        for (int[] row : original) {
            for (int num : row) {
                if (num != 0) nonZeroCount++;
            }
        }

        // 初始化稀疏数组（行=非零数+1，列=3）
        int[][] sparse = new int[nonZeroCount + 1][3];
        sparse[0] = new int[]{rows, cols, nonZeroCount}; // 表头

        // 填充非零元素（从行1开始，顺序存储）
        int index = 1;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (original[i][j] != 0) {
                    sparse[index] = new int[]{i, j, original[i][j]};
                    index++;
                }
            }
        }
        return sparse;
    }

    /**
     * 上下翻转二维数组（行逆序，不修改原数组）
     * @param array 原数组
     * @return 翻转后的新数组
     */
    public static int[][] reverseRows(int[][] array) {
        if (array == null || array.length == 0) return new int[0][0];

        int rows = array.length;
        int[][] reversed = new int[rows][];
        // 逆序复制行（直接引用原行的数据，因为原数组不会被修改）
        for (int i = 0; i < rows; i++) {
            reversed[i] = array[rows - 1 - i];
        }
        return reversed;
    }

    /**
     * 打印棋盘（格式化输出）
     * @param board 棋盘数组
     */
    public static void printBoard(int[][] board) {
        for (int[] row : board) {
            System.out.println(Arrays.toString(row));
        }
    }
}